CQRS Pattern

TL;DR

CQRS (Command Query Responsibility Segregation) splits the write path (commands that mutate state and enforce invariants) from the read path (queries that fetch denormalized projections), so each side scales, optimizes, and secures independently. It pairs naturally with MediatR pipelines and event sourcing, but adds complexity — reach for it only when read/write workloads diverge or you need an audit trail.

How it works

!CQRS-Pattern

🧩 Example — PlaceOrder (Command) vs GetOrder (Query)

public record PlaceOrderCommand(string Symbol, double Amount);
public record GetOrderQuery(Guid OrderId);

public class Order
{
    public Guid Id { get; set; } = Guid.NewGuid();
    public string Symbol { get; set; }
    public double Amount { get; set; }
}

public class OrderCommandHandler
{
    private readonly ITradeExecutor _executor;

    public OrderCommandHandler(ITradeExecutor executor) => _executor = executor;

    public void Handle(PlaceOrderCommand command)
    {
        var order = new Order { Symbol = command.Symbol, Amount = command.Amount };
        _executor.Execute(order);
    }
}

public class OrderQueryHandler
{
    private readonly Dictionary<Guid, Order> _orders = new();

    public Order Handle(GetOrderQuery query)
        => _orders.TryGetValue(query.OrderId, out var order)
            ? order
            : throw new KeyNotFoundException("Order not found");
}

// --- Usage ---
var executor = new Mt5Executor();
var commandHandler = new OrderCommandHandler(executor);
commandHandler.Handle(new PlaceOrderCommand("EURUSD", 1000));

var queryHandler = new OrderQueryHandler();
// queryHandler.Handle(new GetOrderQuery(...));

✅ Why it matters:

• Commands → mutate state (place/cancel order).
• Queries → fetch data (get portfolio, prices).
• Enables scalability (separate read/write services) and event sourcing (audit trading actions).

Quick recall Q&A